home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 85 / CD Temático 40 Febrero 2004.iso / DOS / ntfs / common / inode.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-11  |  33.4 KB  |  1,321 lines
  1. /*
  2.  *  inode.c
  3.  *
  4.  *  Copyright (C) 1995-1999 Martin von L÷wis
  5.  *  Copyright (C) 1996 Albert D. Cahalan
  6.  *  Copyright (C) 1996-1997 RΘgis Duchesne
  7.  *  Copyright (C) 1998 Joseph Malicki
  8.  *  Copyright (C) 1999 Steve Dodd
  9.  */
  10.  
  11. #include "ntfstypes.h"
  12. #include "ntfsendian.h"
  13. #include "struct.h"
  14. #include "inode.h"
  15.  
  16. #include <errno.h>
  17. #ifdef HAVE_STRING_H
  18. #include <string.h>
  19. #endif
  20. #include "macros.h"
  21. #include "attr.h"
  22. #include "super.h"
  23. #include "dir.h"
  24. #include "support.h"
  25. #include "util.h"
  26.  
  27. typedef struct {
  28.     int recno;
  29.     unsigned char* record;
  30. } ntfs_mft_record;
  31.  
  32. typedef struct {
  33.     int size;
  34.     int count;
  35.     ntfs_mft_record* records;
  36. } ntfs_disk_inode;
  37.  
  38. void
  39. ntfs_fill_mft_header(ntfs_u8*mft,int record_size,int blocksize,
  40.         int sequence_number)
  41. {
  42.     int fixup_count = record_size / blocksize + 1;
  43.     int attr_offset = (0x2a + (2 * fixup_count) + 7) & ~7;
  44.     int fixup_offset = 0x2a;
  45.  
  46.     NTFS_PUTU32(mft + 0x00, 0x454c4946);         /* FILE */
  47.     NTFS_PUTU16(mft + 0x04, 0x2a);               /* offset to fixup */
  48.     NTFS_PUTU16(mft + 0x06, fixup_count);        /* Number of fixups */
  49.     NTFS_PUTU16(mft + 0x10, sequence_number);
  50.     NTFS_PUTU16(mft + 0x12, 1);                  /* hard link count */
  51.     NTFS_PUTU16(mft + 0x14, attr_offset);        /* Offset to attributes */
  52.     NTFS_PUTU16(mft + 0x16, 1);                  /*FIXME: flags ?? */
  53.     NTFS_PUTU32(mft + 0x18, attr_offset + 0x08);    /* In use */
  54.     NTFS_PUTU32(mft + 0x1c, record_size);        /* Total size */
  55.  
  56.     NTFS_PUTU16(mft + fixup_offset, 1);             /* Fixup word */
  57.     NTFS_PUTU32(mft + attr_offset, 0xffffffff);     /* End marker */
  58. }
  59.  
  60. /* Search in an inode an attribute by type and name */
  61. ntfs_attribute* 
  62. ntfs_find_attr(ntfs_inode *ino,int type,char *name)
  63. {
  64.     int i;
  65.     if(!ino){
  66.         ntfs_error("ntfs_find_attr: NO INODE!\n");
  67.         return 0;
  68.     }
  69.     for(i=0;i<ino->attr_count;i++)
  70.     {
  71.         if(type==ino->attrs[i].type)
  72.         {
  73.             if(!name && !ino->attrs[i].name)
  74.                 return ino->attrs+i;
  75.             if(name && !ino->attrs[i].name)
  76.                 return 0;
  77.             if(!name && ino->attrs[i].name)
  78.                 return 0;
  79.             if(ntfs_ua_strncmp(ino->attrs[i].name,name,strlen(name))==0)
  80.                 return ino->attrs+i;
  81.         }
  82.         if(type<ino->attrs[i].type)
  83.             return 0;
  84.     }
  85.     return 0;
  86. }
  87.  
  88. /* FIXME: need better strategy to extend the MFT */
  89. static int 
  90. ntfs_extend_mft(ntfs_volume *vol)
  91. {
  92.     /* Try to allocate at least 0.1% of the remaining disk space
  93.        for inodes. If the disk is almost full, make sure at least one
  94.        inode is requested.
  95.      */
  96.     int size,rcount,error,block;
  97.     ntfs_attribute* mdata,*bmp;
  98.     ntfs_u8 *buf;
  99.     ntfs_io io;
  100.  
  101.     mdata=ntfs_find_attr(vol->mft_ino,vol->at_data,0);
  102.     /* first check whether there is uninitialized space */
  103.     if(mdata->allocated<mdata->size+vol->mft_recordsize){
  104.         size=ntfs_get_free_cluster_count(vol->bitmap)*vol->clustersize;
  105.         block=vol->mft_recordsize;
  106.         size=max(size/1000,mdata->size+vol->mft_recordsize);
  107.         size=((size+block-1)/block)*block;
  108.         /* require this to be a single chunk */
  109.         error=ntfs_extend_attr(vol->mft_ino,mdata,&size,
  110.                        ALLOC_REQUIRE_SIZE);
  111.         /* Try again, now we have the largest available fragment */
  112.         if(error==ENOSPC){
  113.             /* round down to multiple of mft record size */
  114.             size=(size/vol->mft_recordsize)*vol->mft_recordsize;
  115.             if(!size)return ENOSPC;
  116.             error=ntfs_extend_attr(vol->mft_ino,mdata,&size,
  117.                            ALLOC_REQUIRE_SIZE);
  118.         }
  119.         if(error)
  120.             return error;
  121.     }
  122.     /* even though we might have allocated more than needed,
  123.        we initialize only one record */
  124.     mdata->size+=vol->mft_recordsize;
  125.     
  126.     /* now extend the bitmap if necessary*/
  127.     rcount=mdata->size/vol->mft_recordsize;
  128.     bmp=ntfs_find_attr(vol->mft_ino,vol->at_bitmap,0);
  129.     if(bmp->size*8<rcount){ /* less bits than MFT records */
  130.         ntfs_u8 buf[1];
  131.         /* extend bitmap by one byte */
  132.         error=ntfs_resize_attr(vol->mft_ino,bmp,bmp->size+1);
  133.         if(error)return error;
  134.         /* write the single byte */
  135.         buf[0]=0;
  136.         io.fn_put=ntfs_put;
  137.         io.fn_get=ntfs_get;
  138.         io.param=buf;
  139.         io.size=1;
  140.         error=ntfs_write_attr(vol->mft_ino,vol->at_bitmap,0,
  141.                       bmp->size-1,&io);
  142.         if(error)return error;
  143.         if(io.size!=1)return EIO;
  144.     }
  145.  
  146.     /* now fill in the MFT header for the new block */
  147.     buf=ntfs_calloc(vol->mft_recordsize);
  148.     if(!buf)return ENOMEM;
  149.     ntfs_fill_mft_header(buf,vol->mft_recordsize,vol->blocksize,0);
  150.     ntfs_insert_fixups(buf,vol->blocksize);
  151.     io.param=buf;
  152.     io.size=vol->mft_recordsize;
  153.     error=ntfs_write_attr(vol->mft_ino,vol->at_data,0,
  154.                   (rcount-1)*vol->mft_recordsize,&io);
  155.     if(error)return error;
  156.     if(io.size!=vol->mft_recordsize)return EIO;
  157.     error=ntfs_update_inode(vol->mft_ino);
  158.     if(error)return error;
  159.     return 0;
  160. }
  161.  
  162. /* Insert all attributes from the record mftno of the MFT in the inode ino */
  163. void ntfs_insert_mft_attributes(ntfs_inode* ino,char *mft,int mftno)
  164. {
  165.     int i;
  166.     char *it;
  167.     int type,len;
  168.     /* check for duplicate */
  169.     for(i=0;i<ino->record_count;i++)
  170.         if(ino->records[i]==mftno)
  171.             return;
  172.     /* (re-)allocate space if necessary */
  173.     if(ino->record_count % 8==0)
  174.     {
  175.         int *new;
  176.         new = ntfs_malloc((ino->record_count+8)*sizeof(int));
  177.         if( !new )
  178.             return;
  179.         if( ino->records ) {
  180.             for(i=0;i<ino->record_count;i++)
  181.                 new[i] = ino->records[i];
  182.             ntfs_free( ino->records );
  183.         }
  184.         ino->records = new;
  185.     }
  186.     ino->records[ino->record_count]=mftno;
  187.     ino->record_count++;
  188.     it = mft + NTFS_GETU16(mft + 0x14);
  189.     do{
  190.         type=NTFS_GETU32(it);
  191.         len=NTFS_GETU32(it+4);
  192.         if(type!=-1) {
  193.             /* FIXME: check ntfs_insert_attribute for failure (e.g. no mem)? */
  194.             ntfs_insert_attribute(ino,it);
  195.         }
  196.         it+=len;
  197.     }while(type!=-1); /* attribute list ends with type -1 */
  198. }
  199.  
  200. /* Read and insert all the attributes of an 'attribute list' attribute
  201.    Return the number of remaining bytes in *plen
  202. */
  203. static int parse_attributes(ntfs_inode *ino, ntfs_u8 *alist, int *plen)
  204. {
  205.     char *mft;
  206.     int mftno,l,error;
  207.     int last_mft=-1;
  208.     int len=*plen;
  209.     mft=ntfs_malloc(ino->vol->mft_recordsize);
  210.     if( !mft )
  211.         return ENOMEM;
  212.     while(len>8)
  213.     {
  214.         l=NTFS_GETU16(alist+4);
  215.         if(l>len)break;
  216.         /* process an attribute description */
  217.         mftno=NTFS_GETU32(alist+0x10); /* BUG: this is u64 */
  218.         if(mftno!=last_mft){
  219.             last_mft=mftno;
  220.             /* FIXME: avoid loading record if it's 
  221.                already processed */
  222.             error=ntfs_read_mft_record(ino->vol,mftno,mft);
  223.             if(error)return error;
  224.             ntfs_insert_mft_attributes(ino,mft,mftno);
  225.         }
  226.         len-=l;
  227.         alist+=l;
  228.     }
  229.     ntfs_free(mft);
  230.     *plen=len;
  231.     return 0;
  232. }
  233.  
  234. static void ntfs_load_attributes(ntfs_inode* ino)
  235. {
  236.     ntfs_attribute *alist;
  237.     int datasize;
  238.     int offset,len,delta;
  239.     char *buf;
  240.     ntfs_volume *vol=ino->vol;
  241.     ntfs_debug(DEBUG_FILE2, "load_attributes %x 1\n",ino->i_number);
  242.     ntfs_insert_mft_attributes(ino,ino->attr,ino->i_number);
  243.     ntfs_debug(DEBUG_FILE2, "load_attributes %x 2\n",ino->i_number);
  244.     alist=ntfs_find_attr(ino,vol->at_attribute_list,0);
  245.     ntfs_debug(DEBUG_FILE2, "load_attributes %x 3\n",ino->i_number);
  246.     if(!alist)
  247.         return;
  248.     ntfs_debug(DEBUG_FILE2, "load_attributes %x 4\n",ino->i_number);
  249.     datasize=alist->size;
  250.     if(alist->resident)
  251.     {
  252.         parse_attributes(ino,alist->d.data,&datasize);
  253.         return;
  254.     }
  255.     buf=ntfs_malloc(1024);
  256.     if( !buf )
  257.         return;
  258.     delta=0;
  259.     for(offset=0;datasize;datasize-=len)
  260.     {
  261.         ntfs_io io;
  262.         io.fn_put=ntfs_put;
  263.         io.fn_get=0;
  264.         io.param=buf+delta;
  265.         io.size=len=min(datasize,1024-delta);
  266.         if(ntfs_read_attr(ino,vol->at_attribute_list,0,offset,&io)){
  267.             ntfs_error("error in load_attributes\n");
  268.         }
  269.         delta=len;
  270.         parse_attributes(ino,buf,&delta);
  271.         if(delta)
  272.             /* move remaining bytes to buffer start */
  273.             ntfs_memmove(buf,buf+len-delta,delta);
  274.     }
  275.     ntfs_debug(DEBUG_FILE2, "load_attributes %x 5\n",ino->i_number);
  276.     ntfs_free(buf);
  277. }
  278.     
  279. int ntfs_init_inode(ntfs_inode *ino,ntfs_volume *vol,int inum)
  280. {
  281.     char *buf;
  282.     int error;
  283.  
  284.     ntfs_debug(DEBUG_FILE1, "Initializing inode %x\n",inum);
  285.     if(!vol)
  286.         ntfs_error("NO VOLUME!\n");
  287.     ino->i_number=inum;
  288.     ino->vol=vol;
  289.     ino->attr=buf=ntfs_malloc(vol->mft_recordsize);
  290.     if( !buf )
  291.         return ENOMEM;
  292.     error=ntfs_read_mft_record(vol,inum,ino->attr);
  293.     if(error){
  294.         ntfs_debug(DEBUG_OTHER, "init inode: %x failed\n",inum);
  295.         return error;
  296.     }
  297.     ntfs_debug(DEBUG_FILE2, "Init: got mft %x\n",inum);
  298.     ino->sequence_number=NTFS_GETU16(buf+0x10);
  299.     ino->attr_count=0;
  300.     ino->record_count=0;
  301.     ino->records=0;
  302.     ino->attrs=0;
  303.     ntfs_load_attributes(ino);
  304.     ntfs_debug(DEBUG_FILE2, "Init: done %x\n",inum);
  305.     return 0;
  306. }
  307.  
  308. void ntfs_clear_inode(ntfs_inode *ino)
  309. {
  310.     int i;
  311.     if(!ino->attr){
  312.         ntfs_error("ntfs_clear_inode: double free\n");
  313.         return;
  314.     }
  315.     ntfs_free(ino->attr);
  316.     ino->attr=0;
  317.     ntfs_free(ino->records);
  318.     ino->records=0;
  319.     for(i=0;i<ino->attr_count;i++)
  320.     {
  321.         if(ino->attrs[i].name)
  322.             ntfs_free(ino->attrs[i].name);
  323.         if(ino->attrs[i].resident)
  324.         {
  325.             if(ino->attrs[i].d.data)
  326.                 ntfs_free(ino->attrs[i].d.data);
  327.         }else{
  328.             if(ino->attrs[i].d.r.runlist)
  329.                 ntfs_free(ino->attrs[i].d.r.runlist);
  330.         }
  331.     }
  332.     ntfs_free(ino->attrs);
  333.     ino->attrs=0;
  334. }
  335.  
  336. /* Check and fixup a MFT record */
  337. int ntfs_check_mft_record(ntfs_volume *vol,char *record)
  338. {
  339.     return ntfs_fixup_record(vol, record, "FILE", vol->mft_recordsize);
  340. }
  341.  
  342. /* Return (in result) the value indicating the next available attribute 
  343.    chunk number. Works for inodes w/o extension records only */
  344. int ntfs_allocate_attr_number(ntfs_inode *ino, int *result)
  345. {
  346.     if(ino->record_count!=1)
  347.         return EOPNOTSUPP;
  348.     *result=NTFS_GETU16(ino->attr+0x28);
  349.     NTFS_PUTU16(ino->attr+0x28, (*result)+1);
  350.     return 0;
  351. }
  352.  
  353. /* find the location of an attribute in the inode. A name of NULL indicates
  354.    unnamed attributes. Return pointer to attribute or NULL if not found */
  355. char *
  356. ntfs_get_attr(ntfs_inode *ino,int attr,char *name)
  357. {
  358.     /* location of first attribute */
  359.     char *it= ino->attr + NTFS_GETU16(ino->attr + 0x14);
  360.     int type;
  361.     int len;
  362.     /* Only check for magic DWORD here, fixup should have happened before */
  363.     if(!IS_MFT_RECORD(ino->attr))return 0;
  364.     do{
  365.         type=NTFS_GETU32(it);
  366.         len=NTFS_GETU16(it+4);
  367.         /* We found the attribute type. Is the name correct, too? */
  368.         if(type==attr)
  369.         {
  370.             int namelen=NTFS_GETU8(it+9);
  371.             char *name_it;
  372.             /* match given name and attribute name if present,
  373.                make sure attribute name is Unicode */
  374.             for(name_it=it+NTFS_GETU16(it+10);namelen;
  375.                 name++,name_it+=2,namelen--)
  376.                 if(*name_it!=*name || name_it[1])break;
  377.             if(!namelen)break;
  378.         }
  379.         it+=len;
  380.     }while(type!=-1); /* attribute list end with type -1 */
  381.     if(type==-1)return 0;
  382.     return it;
  383. }
  384.  
  385. int 
  386. ntfs_get_attr_size(ntfs_inode*ino,int type,char*name)
  387. {
  388.     ntfs_attribute *attr=ntfs_find_attr(ino,type,name);
  389.     if(!attr)return 0;
  390.     return attr->size;
  391. }
  392.     
  393. int 
  394. ntfs_attr_is_resident(ntfs_inode*ino,int type,char*name)
  395. {
  396.     ntfs_attribute *attr=ntfs_find_attr(ino,type,name);
  397.     if(!attr)return 0;
  398.     return attr->resident;
  399. }
  400.     
  401. /*
  402.  * A run is coded as a type indicator, an unsigned length, and a signed cluster
  403.  * offset.
  404.  * . To save space, length and offset are fields of variable length. The low
  405.  *   nibble of the type indicates the width of the length :), the high nibble
  406.  *   the width of the offset.
  407.  * . The first offset is relative to cluster 0, later offsets are relative to
  408.  *   the previous cluster.
  409.  *
  410.  * This function decodes a run. Length is an output parameter, data and cluster
  411.  * are in/out parameters.
  412.  */
  413. int ntfs_decompress_run(unsigned char **data, int *length, ntfs_cluster_t *cluster,
  414.     int *ctype)
  415. {
  416.     unsigned char type=*(*data)++;
  417.     *ctype=0;
  418.     switch(type & 0xF)
  419.     {
  420.     case 1: *length=NTFS_GETU8(*data);break;
  421.     case 2: *length=NTFS_GETU16(*data);break;
  422.     case 3: *length=NTFS_GETU24(*data);break;
  423.     case 4: *length=NTFS_GETU32(*data);break;
  424.         /* Note: cases 5-8 are probably pointless to code,
  425.            since how many runs > 4GB of length are there?
  426.            at the most, cases 5 and 6 are probably necessary,
  427.            and would also require making length 64-bit
  428.            throughout */
  429.     default:
  430.         ntfs_error("Can't decode run type field %x\n",type);
  431.         return -1;
  432.     }
  433.     *data+=(type & 0xF);
  434.  
  435.     switch(type & 0xF0)
  436.     {
  437.     case 0:    *ctype=2; break;
  438.     case 0x10: *cluster += NTFS_GETS8(*data);break;
  439.     case 0x20: *cluster += NTFS_GETS16(*data);break;
  440.     case 0x30: *cluster += NTFS_GETS24(*data);break;
  441.     case 0x40: *cluster += NTFS_GETS32(*data);break;
  442. #if 0 /* Keep for future, in case ntfs_cluster_t ever becomes 64bit */
  443.     case 0x50: *cluster += NTFS_GETS40(*data);break;
  444.     case 0x60: *cluster += NTFS_GETS48(*data);break;
  445.     case 0x70: *cluster += NTFS_GETS56(*data);break;
  446.     case 0x80: *cluster += NTFS_GETS64(*data);break;        
  447. #endif
  448.     default:
  449.         ntfs_error("Can't decode run type field %x\n",type);
  450.         return -1;
  451.     }
  452.     *data+=(type >> 4);
  453.     return 0;
  454. }
  455.  
  456. /* Reads l bytes of the attribute (attr,name) of ino starting at offset
  457.    on vol into buf. Returns the number of bytes read in the ntfs_io struct.
  458.    Returns 0 on success, errno on failure */
  459. int ntfs_readwrite_attr(ntfs_inode *ino, ntfs_attribute *attr, int offset,
  460.     ntfs_io *dest)
  461. {
  462.     int rnum;
  463.     ntfs_cluster_t cluster,s_cluster,vcn,len;
  464.     int l,chunk,copied;
  465.     int s_vcn;
  466.     int clustersize;
  467.     int error;
  468.  
  469.     clustersize=ino->vol->clustersize;
  470.     l=dest->size;
  471.     if(l==0)
  472.         return 0;
  473.     if(dest->do_read)
  474.     {
  475.         /* if read _starts_ beyond end of stream, return nothing */
  476.         if(offset>=attr->size){
  477.             dest->size=0;
  478.             return 0;
  479.         }
  480.  
  481.         /* if read _extends_ beyond end of stream, return as much
  482.             initialised data as we have */
  483.         if(offset+l>=attr->size) 
  484.             l=dest->size=attr->size-offset;
  485.  
  486.     }else {
  487.         /* fixed by CSA: if writing beyond end, extend attribute */
  488.  
  489.         /* if write extends beyond _allocated_ size, extend attrib */
  490.         if (offset+l>attr->allocated) {
  491.             error=ntfs_resize_attr(ino,attr,offset+l);
  492.             if(error)
  493.                 return error;
  494.         }
  495.  
  496.         /* the amount of initialised data has increased; update */
  497.         /* FIXME: shouldn't we zero-out the section between the old
  498.             initialised length and the write start? */
  499.         if (offset+l > attr->initialized) {
  500.             attr->initialized = offset+l;
  501.             attr->size = offset+l;
  502.         }
  503.     }
  504.     if(attr->resident)
  505.     {
  506.         if(dest->do_read)
  507.             dest->fn_put(dest,(ntfs_u8*)attr->d.data+offset,l);
  508.         else
  509.             dest->fn_get((ntfs_u8*)attr->d.data+offset,dest,l);
  510.         dest->size=l;
  511.         return 0;
  512.     }
  513.     /* read uninitialized data */
  514.     if(offset>=attr->initialized && dest->do_read)
  515.         return ntfs_read_zero(dest,l);
  516.     if(offset+l>attr->initialized && dest->do_read)
  517.     {
  518.         dest->size = chunk = offset+l - attr->initialized;
  519.         error = ntfs_readwrite_attr(ino,attr,offset,dest);
  520.         if(error)
  521.             return error;           
  522.         return ntfs_read_zero(dest,l-chunk);
  523.     }
  524.     if(attr->compressed){
  525.         if(dest->do_read)
  526.             return ntfs_read_compressed(ino,attr,offset,dest);
  527.         else
  528.             return ntfs_write_compressed(ino,attr,offset,dest);
  529.     }
  530.     vcn=0;
  531.     s_vcn = offset/clustersize;
  532.     for(rnum=0;rnum<attr->d.r.len && 
  533.             vcn+attr->d.r.runlist[rnum].len<=s_vcn;rnum++)
  534.         vcn+=attr->d.r.runlist[rnum].len;
  535.     if(rnum==attr->d.r.len)
  536.         /*FIXME: should extend runlist */
  537.         return EOPNOTSUPP;
  538.     
  539.     copied=0;
  540.     while(l)
  541.     {
  542.         s_vcn = offset/clustersize;
  543.         cluster=attr->d.r.runlist[rnum].cluster;
  544.         len=attr->d.r.runlist[rnum].len;
  545.  
  546.         s_cluster = cluster+s_vcn-vcn;
  547.             
  548.         chunk=min((vcn+len)*clustersize-offset,l);
  549.         dest->size=chunk;
  550.         error=ntfs_getput_clusters(ino->vol,s_cluster,
  551.                        offset-s_vcn*clustersize,dest);
  552.         if(error)/* FIXME: maybe return failure */
  553.         {
  554.             ntfs_error("Read error\n");
  555.             dest->size=copied;
  556.             return 0;
  557.         }
  558.         l-=chunk;
  559.         copied+=chunk;
  560.         offset+=chunk;
  561.         if(l && offset>=((vcn+len)*clustersize))
  562.         {
  563.             rnum++;
  564.             vcn+=len;
  565.             cluster = attr->d.r.runlist[rnum].cluster;
  566.             len = attr->d.r.runlist[rnum].len;
  567.         }
  568.     }
  569.     dest->size=copied;
  570.     return 0;
  571. }
  572.  
  573. int ntfs_read_attr(ntfs_inode *ino, int type, char *name, int offset,
  574.     ntfs_io *buf)
  575. {
  576.     ntfs_attribute *attr;
  577.     buf->do_read=1;
  578.     attr=ntfs_find_attr(ino,type,name);
  579.     if(!attr)
  580.         return EINVAL;
  581.     return ntfs_readwrite_attr(ino,attr,offset,buf);
  582. }
  583.  
  584. int ntfs_write_attr(ntfs_inode *ino, int type, char *name, int offset,
  585.         ntfs_io *buf)
  586. {
  587.     ntfs_attribute *attr;
  588.     buf->do_read=0;
  589.     attr=ntfs_find_attr(ino,type,name);
  590.     if(!attr)
  591.         return EINVAL;
  592.     return ntfs_readwrite_attr(ino,attr,offset,buf);
  593. }
  594.  
  595. int ntfs_vcn_to_lcn(ntfs_inode *ino,int vcn)
  596. {
  597.     int rnum;
  598.     ntfs_attribute *data;
  599.     data=ntfs_find_attr(ino,ino->vol->at_data,0);
  600.     /* It's hard to give an error code */
  601.     if(!data)return -1;
  602.     if(data->resident)return -1;
  603.     if(data->compressed)return -1;
  604.     if(data->size <= vcn*ino->vol->clustersize)return -1;
  605.  
  606.  
  607.     /* For Linux, block number 0 represents a hole.
  608.        Hopefully, nobody will attempt to bmap $Boot. */
  609.     if(data->initialized <= vcn*ino->vol->clustersize)
  610.         return 0;
  611.  
  612.     for(rnum=0;rnum<data->d.r.len && 
  613.             vcn>data->d.r.runlist[rnum].len;rnum++)
  614.         vcn-=data->d.r.runlist[rnum].len;
  615.     
  616.     return data->d.r.runlist[rnum].cluster+vcn;
  617. }
  618.  
  619. static int 
  620. allocate_store(ntfs_volume *vol,ntfs_disk_inode *store,int count)
  621. {
  622.     int i;
  623.     if(store->count>count)
  624.         return 0;
  625.     if(store->size<count){
  626.         ntfs_mft_record* n=ntfs_malloc((count+4)*sizeof(ntfs_mft_record));
  627.         if(!n)
  628.             return ENOMEM;
  629.         if(store->size){
  630.             for(i=0;i<store->size;i++)
  631.                 n[i]=store->records[i];
  632.             ntfs_free(store->records);
  633.         }
  634.         store->size=count+4;
  635.         store->records=n;
  636.     }
  637.     for(i=store->count;i<count;i++){
  638.         store->records[i].record=ntfs_malloc(vol->mft_recordsize);
  639.         if(!store->records[i].record)
  640.             return ENOMEM;
  641.         store->count++;
  642.     }
  643.     return 0;
  644. }
  645.  
  646. static void 
  647. deallocate_store(ntfs_disk_inode* store)
  648. {
  649.     int i;
  650.     for(i=0;i<store->count;i++)
  651.         ntfs_free(store->records[i].record);
  652.     ntfs_free(store->records);
  653.     store->count=store->size=0;
  654.     store->records=0;
  655. }
  656.  
  657. int 
  658. layout_runs(ntfs_attribute *attr,char* rec,int* offs,int size)
  659. {
  660.     int i,len,offset,coffs;
  661.     ntfs_cluster_t cluster,rclus;
  662.     ntfs_runlist *rl=attr->d.r.runlist;
  663.     cluster=0;
  664.     offset=*offs;
  665.     for(i=0;i<attr->d.r.len;i++){
  666.         rclus=rl[i].cluster-cluster;
  667.         len=rl[i].len;
  668.         rec[offset]=0;
  669.         if(offset+8>size)
  670.             return E2BIG; /* it might still fit, but this simplifies testing */
  671.         if(len<0x100){
  672.             NTFS_PUTU8(rec+offset+1,len);
  673.             coffs=1;
  674.         }else if(len<0x10000){
  675.             NTFS_PUTU16(rec+offset+1,len);
  676.             coffs=2;
  677.         }else if(len<0x1000000){
  678.             NTFS_PUTU24(rec+offset+1,len);
  679.             coffs=3;
  680.         }else{
  681.             NTFS_PUTU32(rec+offset+1,len);
  682.             coffs=4;
  683.         }
  684.     
  685.         *(rec+offset)|=coffs++;
  686.  
  687.         if(rl[i].cluster==MAX_CLUSTER_T) /*compressed run*/
  688.             /*nothing*/;
  689.         else if(rclus>-0x80 && rclus<0x7F){
  690.             *(rec+offset)|=0x10;
  691.             NTFS_PUTS8(rec+offset+coffs,rclus);
  692.             coffs+=1;
  693.         }else if(rclus>-0x8000 && rclus<0x7FFF){
  694.             *(rec+offset)|=0x20;
  695.             NTFS_PUTS16(rec+offset+coffs,rclus);
  696.             coffs+=2;
  697.         }else if(rclus>-0x800000 && rclus<0x7FFFFF){
  698.             *(rec+offset)|=0x30;
  699.             NTFS_PUTS24(rec+offset+coffs,rclus);
  700.             coffs+=3;
  701.         }else
  702. #if 0 /* In case ntfs_cluster_t ever becomes 64bit */
  703.         if (rclus>-0x80000000LL && rclus<0x7FFFFFFF)
  704. #endif
  705.         {
  706.             *(rec+offset)|=0x40;
  707.             NTFS_PUTS32(rec+offset+coffs,rclus);
  708.             coffs+=4;
  709.         }
  710. #if 0 /* For 64-bit ntfs_cluster_t */
  711.         else if (rclus>-0x8000000000 && rclus<0x7FFFFFFFFF){
  712.             *(rec+offset)|=0x50;
  713.             NTFS_PUTS40(rec+offset+coffs,rclus);
  714.             coffs+=5;
  715.         }else if (rclus>-0x800000000000 && rclus<0x7FFFFFFFFFFF){
  716.             *(rec+offset)|=0x60;
  717.             NTFS_PUTS48(rec+offset+coffs,rclus);
  718.             coffs+=6;
  719.         }else if (rclus>-0x80000000000000 && rclus<0x7FFFFFFFFFFFFF){
  720.             *(rec+offset)|=0x70;
  721.             NTFS_PUTS56(rec+offset+coffs,rclus);
  722.             coffs+=7;
  723.         }else{
  724.             *(rec+offset)|=0x80;
  725.             NTFS_PUTS64(rec+offset+coffs,rclus);
  726.             coffs+=8;
  727.         }
  728. #endif
  729.         offset+=coffs;
  730.         if(rl[i].cluster)
  731.             cluster=rl[i].cluster;
  732.     }
  733.     if(offset>=size)
  734.         return E2BIG;
  735.     /* terminating null */
  736.     *(rec+offset++)=0;
  737.     *offs=offset;
  738.     return 0;
  739. }
  740.  
  741. static void 
  742. count_runs(ntfs_attribute *attr,char *buf)
  743. {
  744.     ntfs_u32 first,count,last,i;
  745.     first=0;
  746.     for(i=0,count=0;i<attr->d.r.len;i++)
  747.         count+=attr->d.r.runlist[i].len;
  748.     last=first+count-1;
  749.  
  750.     NTFS_PUTU64(buf+0x10,first);
  751.     NTFS_PUTU64(buf+0x18,last);
  752. } 
  753.  
  754. static int
  755. layout_attr(ntfs_attribute* attr,char*buf, int size,int *psize)
  756. {
  757.     int asize,error;
  758.     if(size<10)return E2BIG;
  759.     NTFS_PUTU32(buf,attr->type);
  760.     /* fill in length later */
  761.     NTFS_PUTU8(buf+8,attr->resident ? 0:1);
  762.     NTFS_PUTU8(buf+9,attr->namelen);
  763.     /* fill in offset to name later */
  764.     NTFS_PUTU16(buf+0xA,0);
  765.     NTFS_PUTU16(buf+0xC,attr->compressed);
  766.     /* FIXME: assign attribute ID??? */
  767.     NTFS_PUTU16(buf+0xE,attr->attrno);
  768.     if(attr->resident){
  769.         if(size<attr->size+0x18+attr->namelen)return E2BIG;
  770.         asize=0x18;
  771.         NTFS_PUTU32(buf+0x10,attr->size);
  772.         NTFS_PUTU16(buf+0x16,attr->indexed);
  773.         if(attr->name){
  774.             ntfs_memcpy(buf+asize,attr->name,2*attr->namelen);
  775.             NTFS_PUTU16(buf+0xA,asize);
  776.             asize+=2*attr->namelen;
  777.             asize=(asize+7) & ~7;
  778.         }
  779.         NTFS_PUTU16(buf+0x14,asize);
  780.         ntfs_memcpy(buf+asize,attr->d.data,attr->size);
  781.         asize+=attr->size;
  782.     }else{
  783.         /* FIXME: fragments */
  784.         count_runs(attr,buf);
  785.         /* offset to data is added later */
  786.         NTFS_PUTU16(buf+0x22,attr->cengine);
  787.         NTFS_PUTU32(buf+0x24,0);
  788.         NTFS_PUTU64(buf+0x28,attr->allocated);
  789.         NTFS_PUTU64(buf+0x30,attr->size);
  790.         NTFS_PUTU64(buf+0x38,attr->initialized);
  791.         if(attr->compressed){
  792.             NTFS_PUTU64(buf+0x40,attr->compsize);
  793.             asize=0x48;
  794.         }else
  795.             asize=0x40;
  796.         if(attr->name){
  797.             NTFS_PUTU16(buf+0xA,asize);
  798.             ntfs_memcpy(buf+asize,attr->name,2*attr->namelen);
  799.             asize+=2*attr->namelen;
  800.             /* SRD: you whaaa?
  801.             asize=(asize+7) & ~7;*/
  802.         }
  803.         /* asize points at the beginning of the data */
  804.         NTFS_PUTU16(buf+0x20,asize);
  805.         error=layout_runs(attr,buf,&asize,size);
  806.         /* now asize pointes at the end of the data */
  807.         if(error)
  808.             return error;
  809.     }
  810.     asize=(asize+7) & ~7;
  811.     NTFS_PUTU32(buf+4,asize);
  812.     *psize=asize;
  813.     return 0;
  814. }
  815.         
  816.         
  817.  
  818. /* Try to layout ino into store. Return 0 on success,
  819.    E2BIG if it does not fit, 
  820.    ENOMEM if memory allocation problem,
  821.    EOPNOTSUP if beyond our capabilities 
  822. */
  823. int 
  824. layout_inode(ntfs_inode *ino,ntfs_disk_inode *store)
  825. {
  826.     int offset,i;
  827.     ntfs_attribute *attr;
  828.     unsigned char *rec;
  829.     int size,psize;
  830.     int error;
  831.  
  832.     if(ino->record_count>1)
  833.     {
  834.         ntfs_error("layout_inode: attribute lists not supported\n");
  835.         return EOPNOTSUPP;
  836.     }
  837.     error=allocate_store(ino->vol,store,1);
  838.     if(error)
  839.         return error;
  840.     rec=store->records[0].record;
  841.     size=ino->vol->mft_recordsize;
  842.     store->records[0].recno=ino->records[0];
  843.     /* copy header */
  844.     offset=NTFS_GETU16(ino->attr+0x14);
  845.     ntfs_memcpy(rec,ino->attr,offset);
  846.     for(i=0;i<ino->attr_count;i++){
  847.         attr=ino->attrs+i;
  848.         error=layout_attr(attr,rec+offset,size-offset,&psize);
  849.         if(error)return error;
  850.         offset+=psize;
  851. #if 0
  852.         /* copy attribute header */
  853.         ntfs_memcpy(rec+offset,attr->header,
  854.                 min(sizeof(attr->header),size-offset)); /* consider overrun */
  855.         if(attr->namelen)
  856.             /* named attributes are added later */
  857.             return EOPNOTSUPP;
  858.         /* FIXME: assign attribute ID??? */
  859.         if(attr->resident){
  860.             asize=attr->size;
  861.             aoffset=NTFS_GETU16(rec+offset+0x14);
  862.             if(offset+aoffset+asize>size)
  863.                 return E2BIG;
  864.             ntfs_memcpy(rec+offset+aoffset,attr->d.data,asize);
  865.             next=offset+aoffset+asize;
  866.         }else{
  867.             count_runs(attr,rec+offset);
  868.             aoffset=NTFS_GETU16(rec+offset+0x20);
  869.             next=offset+aoffset;
  870.             error=layout_runs(attr,rec,&next,size);
  871.             if(error)
  872.                 return error;
  873.         }
  874.         /* SRD: umm..
  875.         next=(next+7) & ~7; */
  876.         /* is this setting the length? if so maybe we could get
  877.            away with rounding up so long as we set the length first..
  878.            ..except, is the length the only way to get to the next attr?
  879.          */
  880.         NTFS_PUTU16(rec+offset+4,next-offset);
  881.         offset=next;
  882. #endif
  883.     }
  884.     /* terminating attribute */
  885.     if(offset+8<size){
  886.         NTFS_PUTU32(rec+offset,0xFFFFFFFF);
  887.         offset+=4;
  888.         NTFS_PUTU32(rec+offset,0);
  889.         offset+=4;
  890.     }else
  891.         return E2BIG;
  892.     NTFS_PUTU32(rec+0x18,offset);
  893.     return 0;
  894. }
  895.   
  896. int ntfs_update_inode(ntfs_inode *ino)
  897. {
  898.     int error;
  899.     ntfs_disk_inode store;
  900.     ntfs_io io;
  901.     int i;
  902.  
  903.     store.count=store.size=0;
  904.     store.records=0;
  905.     error=layout_inode(ino,&store);
  906.     if(error==E2BIG){
  907.         error = ntfs_split_indexroot(ino);
  908.         if(!error)
  909.             error = layout_inode(ino,&store);
  910.     }
  911.     if(error == E2BIG){
  912.         error = ntfs_attr_allnonresident(ino);
  913.         if(!error)
  914.             error = layout_inode(ino,&store);
  915.     }
  916.     if(error == E2BIG){
  917.         /* should try:
  918.            introduce extension records
  919.            */
  920.         ntfs_error("cannot handle saving inode %x\n",ino->i_number);
  921.         deallocate_store(&store);
  922.         return EOPNOTSUPP;
  923.     }
  924.     if(error){
  925.         deallocate_store(&store);
  926.         return error;
  927.     }
  928.     io.fn_get=ntfs_get;
  929.     io.fn_put=0;
  930.     for(i=0;i<store.count;i++){
  931.         ntfs_insert_fixups(store.records[i].record,ino->vol->blocksize);
  932.         io.param=store.records[i].record;
  933.         io.size=ino->vol->mft_recordsize;
  934.         /* FIXME: is this the right way? */
  935.         error=ntfs_write_attr(
  936.             ino->vol->mft_ino,ino->vol->at_data,0,
  937.             store.records[i].recno*ino->vol->mft_recordsize,&io);
  938.         if(error || io.size!=ino->vol->mft_recordsize){
  939.             /* big trouble, partially written file */
  940.             ntfs_error("Please unmount: write error in inode %x\n",ino->i_number);
  941.             deallocate_store(&store);
  942.             return error?error:EIO;
  943.         }
  944.     }
  945.     return 0;
  946. }       
  947.  
  948.  
  949. void ntfs_decompress(unsigned char *dest, unsigned char *src, ntfs_size_t l)
  950. {
  951.     int head,comp;
  952.     int copied=0;
  953.     unsigned char *stop;
  954.     int bits;
  955.     int tag=0;
  956.     int clear_pos;
  957.     while(1)
  958.     {
  959.         head = NTFS_GETU16(src) & 0xFFF;
  960.         /* high bit indicates that compression was performed */
  961.         comp = NTFS_GETU16(src) & 0x8000;
  962.         src += 2;
  963.         stop = src+head;
  964.         bits = 0;
  965.         clear_pos=0;
  966.         if(head==0)
  967.             /* block is not used */
  968.             return;/* FIXME: copied */
  969.         if(!comp) /* uncompressible */
  970.         {
  971.             ntfs_memcpy(dest,src,0x1000);
  972.             dest+=0x1000;
  973.             copied+=0x1000;
  974.             src+=0x1000;
  975.             if(l==copied)
  976.                 return;
  977.             continue;
  978.         }
  979.         while(src<=stop)
  980.         {
  981.             if(clear_pos>4096)
  982.             {
  983.                 ntfs_error("Error 1 in decompress\n");
  984.                 return;
  985.             }
  986.             if(!bits){
  987.                 tag=NTFS_GETU8(src);
  988.                 bits=8;
  989.                 src++;
  990.                 if(src>stop)
  991.                     break;
  992.             }
  993.             if(tag & 1){
  994.                 int i,len,delta,code,lmask,dshift;
  995.                 code = NTFS_GETU16(src);
  996.                 src+=2;
  997.                 if(!clear_pos)
  998.                 {
  999.                     ntfs_error("Error 2 in decompress\n");
  1000.                     return;
  1001.                 }
  1002.                 for(i=clear_pos-1,lmask=0xFFF,dshift=12;i>=0x10;i>>=1)
  1003.                 {
  1004.                     lmask >>= 1;
  1005.                     dshift--;
  1006.                 }
  1007.                 delta = code >> dshift;
  1008.                 len = (code & lmask) + 3;
  1009.                 for(i=0; i<len; i++)
  1010.                 {
  1011.                     dest[clear_pos]=dest[clear_pos-delta-1];
  1012.                     clear_pos++;
  1013.                     copied++;
  1014.                     if(copied==l)
  1015.                         return;
  1016.                 }
  1017.             }else{
  1018.                 dest[clear_pos++]=NTFS_GETU8(src);
  1019.                 src++;
  1020.                 copied++;
  1021.                 if(copied==l)
  1022.                     return;
  1023.             }
  1024.             tag>>=1;
  1025.             bits--;
  1026.         }
  1027.         dest+=clear_pos;
  1028.     }
  1029. }
  1030.  
  1031. /* Caveat: No range checking in either ntfs_set_bit or ntfs_clear_bit */
  1032. void 
  1033. ntfs_set_bit (unsigned char *byte, int bit)
  1034. {
  1035.     byte += (bit >> 3);
  1036.     bit &= 7;
  1037.     *byte |= (1 << bit);
  1038. }
  1039.  
  1040. void 
  1041. ntfs_clear_bit (unsigned char *byte, int bit)
  1042. {
  1043.     byte += (bit >> 3);
  1044.     bit &= 7;
  1045.     *byte &= ~(1 << bit);
  1046. }
  1047.  
  1048. /* We have to skip the 16 metafiles and the 8 reserved entries */
  1049. static int 
  1050. new_inode (ntfs_volume* vol,int* result)
  1051. {
  1052.     int byte,error;
  1053.     int bit;
  1054.     int size,length;
  1055.     unsigned char value;
  1056.     ntfs_u8 *buffer;
  1057.     ntfs_io io;
  1058.     ntfs_attribute *data;
  1059.  
  1060.     buffer=ntfs_malloc(2048);
  1061.     if(!buffer)return ENOMEM;
  1062.     io.fn_put=ntfs_put;
  1063.     io.fn_get=ntfs_get;
  1064.     io.param=buffer;
  1065.     /* FIXME: bitmaps larger than 2048 bytes */
  1066.     io.size=2048;
  1067.     error=ntfs_read_attr(vol->mft_ino,vol->at_bitmap,0,0,&io);
  1068.     if(error){
  1069.         ntfs_free(buffer);
  1070.         return error;
  1071.     }
  1072.     size=io.size;
  1073.     data=ntfs_find_attr(vol->mft_ino,vol->at_data,0);
  1074.     length=data->size/vol->mft_recordsize;
  1075.  
  1076.     /* SRD: start at byte 0: bits for system files _are_ already set in bitmap */
  1077.     for (byte = 0; 8*byte < length; byte++)
  1078.     {
  1079.         value = buffer[byte];
  1080.         if(value==0xFF)
  1081.             continue;
  1082.         for (bit = 0; (bit < 8) && (8*byte+bit<length); 
  1083.              bit++, value >>= 1)
  1084.         {
  1085.             if (!(value & 1)){
  1086.                 *result=byte*8+bit;
  1087.                 return 0;
  1088.             }
  1089.         }
  1090.     }
  1091.     /* There is no free space.  We must first extend the MFT. */
  1092.     return ENOSPC;
  1093. }
  1094.  
  1095. static int 
  1096. add_mft_header (ntfs_inode *ino)
  1097. {
  1098.     unsigned char* mft;
  1099.     ntfs_volume *vol=ino->vol;
  1100.     mft=ino->attr;
  1101.  
  1102.     ntfs_bzero(mft, vol->mft_recordsize);
  1103.     ntfs_fill_mft_header(mft,vol->mft_recordsize,vol->blocksize,
  1104.             ino->sequence_number);
  1105.     return 0;
  1106. }
  1107.  
  1108. /* We need 0x48 bytes in total */
  1109. static int 
  1110. add_standard_information (ntfs_inode *ino)
  1111. {
  1112.     ntfs_time64_t now;
  1113.     char data[0x30];
  1114.     char *position=data;
  1115.     int error;
  1116.     ntfs_attribute *si;
  1117.  
  1118.     now = ntfs_now();
  1119.     NTFS_PUTU64(position + 0x00, now);              /* File creation */
  1120.     NTFS_PUTU64(position + 0x08, now);              /* Last modification */
  1121.     NTFS_PUTU64(position + 0x10, now);              /* Last mod for MFT */
  1122.     NTFS_PUTU64(position + 0x18, now);              /* Last access */
  1123.  
  1124.     NTFS_PUTU64(position + 0x20, 0x00);             /* MSDOS file perms */
  1125.     NTFS_PUTU64(position + 0x28, 0);               /* unknown */
  1126.     error=ntfs_create_attr(ino,ino->vol->at_standard_information,0,
  1127.                    data,sizeof(data),&si);
  1128.  
  1129.     return error;
  1130. }
  1131.  
  1132. static int 
  1133. add_filename (ntfs_inode* ino, ntfs_inode* dir, 
  1134.           const unsigned char *filename, int length, ntfs_u32 flags)
  1135. {
  1136.     unsigned char   *position;
  1137.     unsigned int    size;
  1138.     ntfs_time64_t   now;
  1139.     int             count;
  1140.     int error;
  1141.     unsigned char* data;
  1142.     ntfs_attribute *fn;
  1143.  
  1144.     /* work out the size */
  1145.     size = 0x42 + 2 * length;
  1146.     data = ntfs_malloc(size);
  1147.     if( !data )
  1148.         return ENOMEM;
  1149.     ntfs_bzero(data,size);
  1150.  
  1151.     /* search for a position */
  1152.     position = data;
  1153.  
  1154.     NTFS_PUTINUM(position, dir);    /* Inode num of dir */
  1155.  
  1156.     now = ntfs_now();
  1157.     NTFS_PUTU64(position + 0x08, now);              /* File creation */
  1158.     NTFS_PUTU64(position + 0x10, now);              /* Last modification */
  1159.     NTFS_PUTU64(position + 0x18, now);              /* Last mod for MFT */
  1160.     NTFS_PUTU64(position + 0x20, now);              /* Last access */
  1161.  
  1162.     /* Don't know */
  1163.     NTFS_PUTU32(position+0x38, flags);
  1164.  
  1165.     NTFS_PUTU8(position + 0x40, length);          /* Filename length */
  1166.     NTFS_PUTU8(position + 0x41, 0x0);             /* only long name */
  1167.  
  1168.     position += 0x42;
  1169.     for (count = 0; count < length; count++)
  1170.     {
  1171.         NTFS_PUTU16(position + 2 * count, filename[count]);
  1172.     }
  1173.  
  1174.     error=ntfs_create_attr(ino,ino->vol->at_file_name,0,data,size,&fn);
  1175.     if(!error)
  1176.         error=ntfs_dir_add(dir,ino,fn);
  1177.     ntfs_free(data);
  1178.     return error;
  1179. }
  1180.  
  1181. int 
  1182. add_security (ntfs_inode* ino, ntfs_inode* dir)
  1183. {
  1184.     int error;
  1185.     char *buf;
  1186.     int size;
  1187.     ntfs_attribute* attr;
  1188.     ntfs_io io;
  1189.     ntfs_attribute *se;
  1190.  
  1191.     attr=ntfs_find_attr(dir,ino->vol->at_security_descriptor,0);
  1192.     if(!attr)
  1193.         return EOPNOTSUPP; /* need security in directory */
  1194.     size = attr->size;
  1195.     if(size>512)
  1196.         return EOPNOTSUPP;
  1197.     buf=ntfs_malloc(size);
  1198.     if(!buf)
  1199.         return ENOMEM;
  1200.     io.fn_get=ntfs_get;
  1201.     io.fn_put=ntfs_put;
  1202.     io.param=buf;
  1203.     io.size=size;
  1204.     error=ntfs_read_attr(dir,ino->vol->at_security_descriptor,0,0,&io);
  1205.     if(!error && io.size!=size)ntfs_error("wrong size in add_security");
  1206.     if(error){
  1207.         ntfs_free(buf);
  1208.         return error;
  1209.     }
  1210.     /* FIXME: consider ACL inheritance */
  1211.     error=ntfs_create_attr(ino,ino->vol->at_security_descriptor,
  1212.                    0,buf,size,&se);
  1213.     ntfs_free(buf);
  1214.     return error;
  1215. }
  1216.  
  1217. static int 
  1218. add_data (ntfs_inode* ino, unsigned char *data, int length)
  1219. {
  1220.     int error;
  1221.     ntfs_attribute *da;
  1222.     error=ntfs_create_attr(ino,ino->vol->at_data,0,data,length,&da);
  1223.     return error;
  1224. }
  1225.  
  1226. /* We _could_ use 'dir' to help optimise inode allocation */
  1227. int ntfs_alloc_inode (ntfs_inode *dir, ntfs_inode *result, 
  1228.               const char *filename, int namelen, ntfs_u32 flags)
  1229. {
  1230.     ntfs_io io;
  1231.     int error;
  1232.     ntfs_u8 buffer[2];
  1233.     ntfs_volume* vol=dir->vol;
  1234.     int byte,bit;
  1235.  
  1236.     error=new_inode (vol,&(result->i_number));
  1237.     if(error==ENOSPC){
  1238.         error=ntfs_extend_mft(vol);
  1239.         if(error)return error;
  1240.         error=new_inode(vol,&(result->i_number));
  1241.     }
  1242.     if(error){
  1243.         ntfs_error ("ntfs_get_empty_inode: no free inodes\n");
  1244.         return error;
  1245.     }
  1246.     byte=result->i_number/8;
  1247.     bit=result->i_number & 7;
  1248.  
  1249.     io.fn_put = ntfs_put;
  1250.     io.fn_get = ntfs_get;
  1251.     io.param = buffer;
  1252.     io.size=1;
  1253.     /* set a single bit */
  1254.     error=ntfs_read_attr(vol->mft_ino,vol->at_bitmap,0,byte,&io);
  1255.     if(error)return error;
  1256.     if(io.size!=1)
  1257.         return EIO;
  1258.     ntfs_set_bit (buffer, bit);
  1259.     io.param = buffer;
  1260.     io.size = 1;
  1261.     error = ntfs_write_attr (vol->mft_ino, vol->at_bitmap, 0, byte, &io);
  1262.     if(error)return error;
  1263.     if (io.size != 1)
  1264.         return EIO;
  1265.     /*FIXME: Should change MFT on disk
  1266.       error=ntfs_update_inode(vol->mft_ino);
  1267.       if(error)return error;
  1268.       */
  1269.     /* get the sequence number */
  1270.     io.param = buffer;
  1271.     io.size = 2;
  1272.     error = ntfs_read_attr(vol->mft_ino, vol->at_data, 0, 
  1273.                    result->i_number*vol->mft_recordsize+0x10,&io);
  1274.     if(error)
  1275.         return error;
  1276.     result->sequence_number=NTFS_GETU16(buffer)+1;
  1277.     result->vol=vol;
  1278.     result->attr=ntfs_malloc(vol->mft_recordsize);
  1279.     if( !result->attr )
  1280.         return ENOMEM;
  1281.     result->attr_count=0;
  1282.     result->attrs=0;
  1283.     result->record_count=1;
  1284.     result->records=ntfs_malloc(8*sizeof(int));
  1285.     if( !result->records ) {
  1286.         ntfs_free( result->attr );
  1287.         result->attr = 0;
  1288.         return ENOMEM;
  1289.     }
  1290.     result->records[0]=result->i_number;
  1291.     error=add_mft_header(result);
  1292.     if(error)
  1293.         return error;
  1294.     error=add_standard_information(result);
  1295.     if(error)
  1296.         return error;
  1297.     error=add_filename(result,dir,filename,namelen,flags);
  1298.     if(error)
  1299.         return error;
  1300.     error=add_security(result,dir);
  1301.     /*FIXME: check error */
  1302.     return 0;
  1303. }
  1304.  
  1305. int
  1306. ntfs_alloc_file(ntfs_inode *dir, ntfs_inode *result, char *filename,
  1307.         int namelen)
  1308. {
  1309.     int error = ntfs_alloc_inode(dir,result,filename,namelen,0);
  1310.     if(error)
  1311.         return error;
  1312.     error = add_data(result,0,0);
  1313.     return error;
  1314. }
  1315.  
  1316. /*
  1317.  * Local variables:
  1318.  * c-file-style: "linux"
  1319.  * End:
  1320.  */
  1321.